/*
区间选点
给定N个闭区间[ai, bi]，请你在数轴上选择尽量少的点，使得每个区间内至少包含一个选出的点。位于区间端点上的点也算作区间内。

输入格式
第一行包含整数N，表示区间数。
接下来N行，每行包含两个整数ai, bi，表示一个区间的两个端点。

输出格式
输出一个整数，表示所需的点的最小数量。

数据范围
1≤N≤10^5
-10^9≤ai≤bi≤10^9

输入样例：
3
-1 1
2 4
3 5

输出样例：
2
 */

//import java.util.*;
//
//public class Main {
//    static class pair {
//        int start;
//        int end;
//
//        public pair(int start, int end) {
//            this.start = start;
//            this.end = end;
//        }
//
//        int start() {
//            return start;
//        }
//
//        int end() {
//            return end;
//        }
//
//        void setStart(int start) {
//            this.start = start;
//        }
//
//        void setEnd(int end) {
//            this.end = end;
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        pair[] pairs = new pair[n];
//        for (int i = 0; i < n; i++) {
//            pairs[i] = new pair(sc.nextInt(), sc.nextInt());
//        }
//        Arrays.sort(pairs, Comparator.comparingInt(pair::end));
//        int res = 0;
//        int cur = (int) -2e9;
//        for (int i = 0; i < n; i++) {
//            int s = pairs[i].start();
//            int e = pairs[i].end();
//            if (s <= cur && cur <= e) continue;
//            else {
//                res++;
//                cur = e;
//            }
//        }
//        System.out.println(res);
//    }
//}

/*
给定N个闭区间[ai, bi]，请你将这些区间分成若干组，使得每组内部的区间两两之间（包括端点）没有交集，并使得组数尽可能小。输出最小组数。

输入格式
第一行包含整数N，表示区间数。
接下来N行，每行包含两个整数ai, bi，表示一个区间的两个端点。

输出格式
输出一个整数，表示最小组数。

数据范围
1≤N≤10^5
-10^9≤ai≤bi≤10^9

输入样例：
3
-1 1
2 4
3 5

输出样例：
2
 */
//import java.util.*;
//
//public class Main {
//    static class Interval {
//        int start;
//        int end;
//        public Interval(int start, int end) {
//            this.start = start;
//            this.end = end;
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        int n = sc.nextInt();
//        Interval[] intervals = new Interval[n];
//        for (int i = 0; i < n; i++) {
//            intervals[i] = new Interval(sc.nextInt(), sc.nextInt());
//        }
//
//        // 按起始点排序
//        Arrays.sort(intervals, (a, b) -> a.start - b.start);
//
//        // 使用最小堆维护各组的最右端点
//        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
//
//        for (Interval interval : intervals) {
//            if (!minHeap.isEmpty() && minHeap.peek() < interval.start) {
//                // 可以放入已有组
//                minHeap.poll();
//            }
//            minHeap.offer(interval.end);
//        }
//
//        System.out.println(minHeap.size());
//    }
//}

/*
给定N个闭区间[ai, bi]以及一个线段区间[s, t]，请你选择尽量少的区间，将指定线段区间完全覆盖。输出最少区间数，如果无法完全覆盖则输出-1。

输入格式
第一行包含两个整数s和t，表示给定线段区间的两个端点。
第二行包含整数N，表示给定区间数。
接下来N行，每行包含两个整数ai和bi，表示一个区间的两个端点。

输出格式
输出一个整数，表示所需最少区间数。
如果无解，则输出-1。

数据范围
-10^9 ≤ ai ≤ bi ≤ 10^9
-10^9 ≤ s ≤ t ≤ 10^9

输入样例：
1 5
3
-1 3
2 4
3 5

输出样例：
2
 */

import java.util.*;

public class Main {
    static class Interval {
        int start;
        int end;
        public Interval(int start, int end) {
            this.start = start;
            this.end = end;
        }
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int s = sc.nextInt(), t = sc.nextInt();
        int n = sc.nextInt();
        Interval[] intervals = new Interval[n];
        for (int i = 0; i < n; i++) {
            intervals[i] = new Interval(sc.nextInt(), sc.nextInt());
        }

        Arrays.sort(intervals, (a, b) -> a.start - b.start);

        int res = 0;
        int current = s;
        int i = 0;
        while (current < t) {
            int maxEnd = current;
            // 找到能覆盖current且右端点最大的区间
            while (i < n && intervals[i].start <= current) {
                maxEnd = Math.max(maxEnd, intervals[i].end);
                i++;
            }

            if (maxEnd == current) { // 没有找到能覆盖的区间
                System.out.println(-1);
                return;
            }

            res++;
            current = maxEnd;
        }

        System.out.println(res);
    }
}